
/**
 * 
 * 数组拼接
 * 
 * 题目描述

现在有多组整数数组，需要将它们合并成一个新的数组。

合并规则，从每个数组里按顺序取出固定长度的内容合并到新的数组中，取完的内容会删除掉，如果该行不足固定长度或者已经为空，则直接取出剩余部分的内容放到新的数组中，继续下一行。

输入描述
第一行是每次读取的固定长度，0 < 长度 < 10

第二行是整数数组的数目，0 < 数目 < 1000

第3-n行是需要合并的数组，不同的数组用回车换行分隔，数组内部用逗号分隔，最大不超过100个元素。

输出描述
输出一个新的数组，用逗号分隔。

用例
输入	
3
2
2,5,6,7,9,5,7
1,7,4,3,4
输出	2,5,6,1,7,4,7,9,5,3,4,7
说明	1、获得长度3和数组数目2
2、先遍历第一行，获得2,5,6
3、再遍历第二行，获得1,7,4
4、再循环回到第一行，获得7,9,5
5、再遍历第二行，获得3,4
6、再回到第一行，获得7，按顺序拼接成最终结果
输入	4
3
1,2,3,4,5,6
1,2,3
1,2,3,4
输出	1,2,3,4,1,2,3,1,2,3,4,5,6
说明	无
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.StringJoiner;
import java.util.stream.Collectors;

/**
  * 
  题目解析
假设，第一行输入的固定长度是subLen。

我的解题思路如下：

首先，定义一个动态数组ans，来记录题解。

然后，将输入的3~n行对应的数组，放到一个链表中。

每次取出链表的头部，然后删除该头部数组前subLen个元素，并这subLen元素记录按顺序录入ans中：

如果删除后，该头部数组长度依旧大于0，则将该头部数组重新连接到链表尾部
如果删除后，该头部数组的长度为0，则不做操作
直到链表长度为0时，停止。此时ans中记录的就是题解。

本题，主要难点在于，如何删除数组（或其他容器）的前subLen个元素，其实就是删除容器中某个范围的所有元素。
  */

public class 数组拼接 {
    
    public static void main(String[] args) {
        
        try{

            Scanner scanner = new Scanner(System.in);

            //每次截取长度
            int subLen = Integer.parseInt(scanner.nextLine());
            //列表个数
            int listCount = Integer.parseInt(scanner.nextLine());

            LinkedList<LinkedList<Integer>> originList = new LinkedList<>();

            for(int i=0; i<listCount; i++){

                originList.add(
                    new LinkedList<>(
                        Arrays.stream(scanner.nextLine().split(","))
                        // 输入用例中的数组存在 4,,6 这种情况，所以这里需要过滤掉空串
                        .filter(a -> !"".equals(a))
                        //转 list 时 需要 map 不能 mapToInt
                        .map(Integer::parseInt)
                        .collect(Collectors.toList())
                    )
                );
            }

            LinkedList<Integer> result = new LinkedList<>();

            //解析数据
            while (!originList.isEmpty()) {
                
                LinkedList<Integer> list = originList.removeFirst();

                //subLen = Math.min(subLen, list.size());

                result.addAll(removeRange(list, 0, subLen));
                if (list.size() > 0) originList.addLast(list);
            }


            StringJoiner sj = new StringJoiner(",");
            for (Integer an : result) {
                sj.add(an + "");
             }
            
            
             System.out.println(sj.toString());




        }catch(Exception e){

            e.printStackTrace();
        }
    }

    public static List<Integer> removeRange(LinkedList<Integer> list, int start, int end) {
        if (end > list.size()) end = list.size();
     
        List<Integer> tmp = list.subList(start, end);
     
        //临时变量，用来返回
        List<Integer> ans = new ArrayList<>(tmp);
        //删除 start ～ end 区间的内容
        tmp.clear();
     
        return ans;
      }
}
